﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a metrology model.</summary>
	// Token: 0x0200004B RID: 75
	[Serializable]
	public class HMetrologyModel : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06000A30 RID: 2608 RVA: 0x00040C74 File Offset: 0x0003EE74
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMetrologyModel(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000A31 RID: 2609 RVA: 0x00040C83 File Offset: 0x0003EE83
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMetrologyModel(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000A32 RID: 2610 RVA: 0x00040C92 File Offset: 0x0003EE92
		private void AssertSemType()
		{
			base.AssertSemType("metrology_model");
		}

		// Token: 0x06000A33 RID: 2611 RVA: 0x00040C9F File Offset: 0x0003EE9F
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HMetrologyModel obj)
		{
			obj = new HMetrologyModel(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06000A34 RID: 2612 RVA: 0x00040CB8 File Offset: 0x0003EEB8
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HMetrologyModel[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HMetrologyModel[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HMetrologyModel(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a metrology model from a file.
		///   Modified instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000A35 RID: 2613 RVA: 0x00040D28 File Offset: 0x0003EF28
		public HMetrologyModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(798);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create the data structure that is needed to measure geometric shapes.
		///   Modified instance represents: Handle of the metrology model.
		/// </summary>
		// Token: 0x06000A36 RID: 2614 RVA: 0x00040D74 File Offset: 0x0003EF74
		public HMetrologyModel()
		{
			IntPtr proc = HalconAPI.PreCall(820);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06000A37 RID: 2615 RVA: 0x00040DB8 File Offset: 0x0003EFB8
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeMetrologyModel();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06000A38 RID: 2616 RVA: 0x00040DF0 File Offset: 0x0003EFF0
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HMetrologyModel(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeMetrologyModel(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06000A39 RID: 2617 RVA: 0x00040E30 File Offset: 0x0003F030
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeMetrologyModel();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000A3A RID: 2618 RVA: 0x00040E44 File Offset: 0x0003F044
		public new static HMetrologyModel Deserialize(Stream stream)
		{
			HMetrologyModel hmetrologyModel = new HMetrologyModel();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hmetrologyModel.DeserializeMetrologyModel(hserializedItem);
			hserializedItem.Dispose();
			return hmetrologyModel;
		}

		// Token: 0x06000A3B RID: 2619 RVA: 0x00040E6A File Offset: 0x0003F06A
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000A3C RID: 2620 RVA: 0x00040E74 File Offset: 0x0003F074
		public new HMetrologyModel Clone()
		{
			HSerializedItem hserializedItem = this.SerializeMetrologyModel();
			HMetrologyModel hmetrologyModel = new HMetrologyModel();
			hmetrologyModel.DeserializeMetrologyModel(hserializedItem);
			hserializedItem.Dispose();
			return hmetrologyModel;
		}

		/// <summary>
		///   Query the model contour of a metrology object in image coordinates. 
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.5</param>
		/// <returns>Model contour.</returns>
		// Token: 0x06000A3D RID: 2621 RVA: 0x00040E9C File Offset: 0x0003F09C
		public HXLDCont GetMetrologyObjectModelContour(HTuple index, double resolution)
		{
			IntPtr proc = HalconAPI.PreCall(788);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.StoreD(proc, 2, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the model contour of a metrology object in image coordinates. 
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.5</param>
		/// <returns>Model contour.</returns>
		// Token: 0x06000A3E RID: 2622 RVA: 0x00040EFC File Offset: 0x0003F0FC
		public HXLDCont GetMetrologyObjectModelContour(int index, double resolution)
		{
			IntPtr proc = HalconAPI.PreCall(788);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, index);
			HalconAPI.StoreD(proc, 2, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the result contour of a metrology object. 
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="instance">Instance of the metrology object. Default: "all"</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.5</param>
		/// <returns>Result contour for the given metrology object.</returns>
		// Token: 0x06000A3F RID: 2623 RVA: 0x00040F54 File Offset: 0x0003F154
		public HXLDCont GetMetrologyObjectResultContour(HTuple index, HTuple instance, double resolution)
		{
			IntPtr proc = HalconAPI.PreCall(789);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, instance);
			HalconAPI.StoreD(proc, 3, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(instance);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the result contour of a metrology object. 
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="instance">Instance of the metrology object. Default: "all"</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.5</param>
		/// <returns>Result contour for the given metrology object.</returns>
		// Token: 0x06000A40 RID: 2624 RVA: 0x00040FC0 File Offset: 0x0003F1C0
		public HXLDCont GetMetrologyObjectResultContour(int index, string instance, double resolution)
		{
			IntPtr proc = HalconAPI.PreCall(789);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, index);
			HalconAPI.StoreS(proc, 2, instance);
			HalconAPI.StoreD(proc, 3, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Alignment of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row coordinate of the alignment. Default: 0</param>
		/// <param name="column">Column coordinate of the alignment. Default: 0</param>
		/// <param name="angle">Rotation angle of the alignment. Default: 0</param>
		// Token: 0x06000A41 RID: 2625 RVA: 0x00041020 File Offset: 0x0003F220
		public void AlignMetrologyModel(HTuple row, HTuple column, HTuple angle)
		{
			IntPtr proc = HalconAPI.PreCall(790);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, angle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(angle);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Alignment of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row coordinate of the alignment. Default: 0</param>
		/// <param name="column">Column coordinate of the alignment. Default: 0</param>
		/// <param name="angle">Rotation angle of the alignment. Default: 0</param>
		// Token: 0x06000A42 RID: 2626 RVA: 0x00041080 File Offset: 0x0003F280
		public void AlignMetrologyModel(double row, double column, double angle)
		{
			IntPtr proc = HalconAPI.PreCall(790);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, angle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Add a metrology object to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="shape">Type of the metrology object to be added. Default: "circle"</param>
		/// <param name="shapeParam">Parameters of the metrology object to be added.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A43 RID: 2627 RVA: 0x000410CC File Offset: 0x0003F2CC
		public int AddMetrologyObjectGeneric(HTuple shape, HTuple shapeParam, HTuple measureLength1, HTuple measureLength2, HTuple measureSigma, HTuple measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(791);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, shape);
			HalconAPI.Store(proc, 2, shapeParam);
			HalconAPI.Store(proc, 3, measureLength1);
			HalconAPI.Store(proc, 4, measureLength2);
			HalconAPI.Store(proc, 5, measureSigma);
			HalconAPI.Store(proc, 6, measureThreshold);
			HalconAPI.Store(proc, 7, genParamName);
			HalconAPI.Store(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(shape);
			HalconAPI.UnpinTuple(shapeParam);
			HalconAPI.UnpinTuple(measureLength1);
			HalconAPI.UnpinTuple(measureLength2);
			HalconAPI.UnpinTuple(measureSigma);
			HalconAPI.UnpinTuple(measureThreshold);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a metrology object to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="shape">Type of the metrology object to be added. Default: "circle"</param>
		/// <param name="shapeParam">Parameters of the metrology object to be added.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A44 RID: 2628 RVA: 0x00041190 File Offset: 0x0003F390
		public int AddMetrologyObjectGeneric(string shape, HTuple shapeParam, double measureLength1, double measureLength2, double measureSigma, double measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(791);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, shape);
			HalconAPI.Store(proc, 2, shapeParam);
			HalconAPI.StoreD(proc, 3, measureLength1);
			HalconAPI.StoreD(proc, 4, measureLength2);
			HalconAPI.StoreD(proc, 5, measureSigma);
			HalconAPI.StoreD(proc, 6, measureThreshold);
			HalconAPI.Store(proc, 7, genParamName);
			HalconAPI.Store(proc, 8, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(shapeParam);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get parameters that are valid for the entire metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="genParamName">Name of the generic parameter. Default: "camera_param"</param>
		/// <returns>Value of the generic parameter.</returns>
		// Token: 0x06000A45 RID: 2629 RVA: 0x00041234 File Offset: 0x0003F434
		public HTuple GetMetrologyModelParam(string genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(792);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set parameters that are valid for the entire metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="genParamName">Name of the generic parameter. Default: "camera_param"</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		// Token: 0x06000A46 RID: 2630 RVA: 0x00041284 File Offset: 0x0003F484
		public void SetMetrologyModelParam(string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(793);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters that are valid for the entire metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="genParamName">Name of the generic parameter. Default: "camera_param"</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: []</param>
		// Token: 0x06000A47 RID: 2631 RVA: 0x000412D0 File Offset: 0x0003F4D0
		public void SetMetrologyModelParam(string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(793);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Deserialize a serialized metrology model.
		///   Modified instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000A48 RID: 2632 RVA: 0x00041314 File Offset: 0x0003F514
		public void DeserializeMetrologyModel(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(794);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000A49 RID: 2633 RVA: 0x00041368 File Offset: 0x0003F568
		public HSerializedItem SerializeMetrologyModel()
		{
			IntPtr proc = HalconAPI.PreCall(795);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform metrology objects of a metrology model, e.g. for alignment.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="row">Translation in row direction.</param>
		/// <param name="column">Translation in column direction.</param>
		/// <param name="phi">Rotation angle.</param>
		/// <param name="mode">Mode of the transformation. Default: "absolute"</param>
		// Token: 0x06000A4A RID: 2634 RVA: 0x000413B0 File Offset: 0x0003F5B0
		public void TransformMetrologyObject(HTuple index, HTuple row, HTuple column, HTuple phi, HTuple mode)
		{
			IntPtr proc = HalconAPI.PreCall(796);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.Store(proc, 4, phi);
			HalconAPI.Store(proc, 5, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(mode);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Transform metrology objects of a metrology model, e.g. for alignment.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="row">Translation in row direction.</param>
		/// <param name="column">Translation in column direction.</param>
		/// <param name="phi">Rotation angle.</param>
		/// <param name="mode">Mode of the transformation. Default: "absolute"</param>
		// Token: 0x06000A4B RID: 2635 RVA: 0x00041430 File Offset: 0x0003F630
		public void TransformMetrologyObject(string index, double row, double column, double phi, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(796);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.StoreD(proc, 2, row);
			HalconAPI.StoreD(proc, 3, column);
			HalconAPI.StoreD(proc, 4, phi);
			HalconAPI.StoreS(proc, 5, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write a metrology model to a file.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000A4C RID: 2636 RVA: 0x00041490 File Offset: 0x0003F690
		public void WriteMetrologyModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(797);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read a metrology model from a file.
		///   Modified instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000A4D RID: 2637 RVA: 0x000414CC File Offset: 0x0003F6CC
		public void ReadMetrologyModel(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(798);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Copy a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <returns>Handle of the copied metrology model.</returns>
		// Token: 0x06000A4E RID: 2638 RVA: 0x00041518 File Offset: 0x0003F718
		public int CopyMetrologyModel(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(799);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Copy a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <returns>Handle of the copied metrology model.</returns>
		// Token: 0x06000A4F RID: 2639 RVA: 0x00041570 File Offset: 0x0003F770
		public int CopyMetrologyModel(string index)
		{
			IntPtr proc = HalconAPI.PreCall(799);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Copy metrology metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <returns>Indices of the copied metrology objects.</returns>
		// Token: 0x06000A50 RID: 2640 RVA: 0x000415C0 File Offset: 0x0003F7C0
		public HTuple CopyMetrologyObject(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(800);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Copy metrology metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <returns>Indices of the copied metrology objects.</returns>
		// Token: 0x06000A51 RID: 2641 RVA: 0x00041618 File Offset: 0x0003F818
		public int CopyMetrologyObject(string index)
		{
			IntPtr proc = HalconAPI.PreCall(800);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the number of instances of the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: 0</param>
		/// <returns>Number of Instances of the metrology objects.</returns>
		// Token: 0x06000A52 RID: 2642 RVA: 0x00041668 File Offset: 0x0003F868
		public HTuple GetMetrologyObjectNumInstances(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(801);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the number of instances of the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: 0</param>
		/// <returns>Number of Instances of the metrology objects.</returns>
		// Token: 0x06000A53 RID: 2643 RVA: 0x000416C0 File Offset: 0x0003F8C0
		public double GetMetrologyObjectNumInstances(int index)
		{
			IntPtr proc = HalconAPI.PreCall(801);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, index);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the results of the measurement of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="instance">Instance of the metrology object. Default: "all"</param>
		/// <param name="genParamName">Name of the generic parameter. Default: "result_type"</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: "all_param"</param>
		/// <returns>Result values.</returns>
		// Token: 0x06000A54 RID: 2644 RVA: 0x00041710 File Offset: 0x0003F910
		public HTuple GetMetrologyObjectResult(HTuple index, HTuple instance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(802);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, instance);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(instance);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the results of the measurement of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology object. Default: 0</param>
		/// <param name="instance">Instance of the metrology object. Default: "all"</param>
		/// <param name="genParamName">Name of the generic parameter. Default: "result_type"</param>
		/// <param name="genParamValue">Value of the generic parameter. Default: "all_param"</param>
		/// <returns>Result values.</returns>
		// Token: 0x06000A55 RID: 2645 RVA: 0x00041794 File Offset: 0x0003F994
		public HTuple GetMetrologyObjectResult(int index, string instance, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(802);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, index);
			HalconAPI.StoreS(proc, 2, instance);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the measure regions and the results of the edge location for the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="transition">Select light/dark or dark/light edges. Default: "all"</param>
		/// <param name="row">Row coordinates of the measured edges.</param>
		/// <param name="column">Column coordinates of the measured edges.</param>
		/// <returns>Rectangular XLD Contours of measure regions.</returns>
		// Token: 0x06000A56 RID: 2646 RVA: 0x0004180C File Offset: 0x0003FA0C
		public HXLDCont GetMetrologyObjectMeasures(HTuple index, string transition, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(803);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.StoreS(proc, 2, transition);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the measure regions and the results of the edge location for the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="transition">Select light/dark or dark/light edges. Default: "all"</param>
		/// <param name="row">Row coordinates of the measured edges.</param>
		/// <param name="column">Column coordinates of the measured edges.</param>
		/// <returns>Rectangular XLD Contours of measure regions.</returns>
		// Token: 0x06000A57 RID: 2647 RVA: 0x00041894 File Offset: 0x0003FA94
		public HXLDCont GetMetrologyObjectMeasures(string index, string transition, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(803);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.StoreS(proc, 2, transition);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Measure and fit the geometric shapes of all metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="image">Input image.</param>
		// Token: 0x06000A58 RID: 2648 RVA: 0x00041914 File Offset: 0x0003FB14
		public void ApplyMetrologyModel(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(804);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Get the indices of the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <returns>Indices of the metrology objects.</returns>
		// Token: 0x06000A59 RID: 2649 RVA: 0x00041958 File Offset: 0x0003FB58
		public HTuple GetMetrologyObjectIndices()
		{
			IntPtr proc = HalconAPI.PreCall(805);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reset all fuzzy parameters and fuzzy functions of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A5A RID: 2650 RVA: 0x000419A4 File Offset: 0x0003FBA4
		public void ResetMetrologyObjectFuzzyParam(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(806);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Reset all fuzzy parameters and fuzzy functions of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A5B RID: 2651 RVA: 0x000419E8 File Offset: 0x0003FBE8
		public void ResetMetrologyObjectFuzzyParam(string index)
		{
			IntPtr proc = HalconAPI.PreCall(806);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Reset all parameters of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A5C RID: 2652 RVA: 0x00041A24 File Offset: 0x0003FC24
		public void ResetMetrologyObjectParam(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(807);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Reset all parameters of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A5D RID: 2653 RVA: 0x00041A68 File Offset: 0x0003FC68
		public void ResetMetrologyObjectParam(string index)
		{
			IntPtr proc = HalconAPI.PreCall(807);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get a fuzzy parameter of a metroloy model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "fuzzy_thresh"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000A5E RID: 2654 RVA: 0x00041AA4 File Offset: 0x0003FCA4
		public HTuple GetMetrologyObjectFuzzyParam(HTuple index, HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(808);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get a fuzzy parameter of a metroloy model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "fuzzy_thresh"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000A5F RID: 2655 RVA: 0x00041B08 File Offset: 0x0003FD08
		public HTuple GetMetrologyObjectFuzzyParam(string index, HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(808);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get one or several parameters of a metroloy model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "num_measures"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000A60 RID: 2656 RVA: 0x00041B68 File Offset: 0x0003FD68
		public HTuple GetMetrologyObjectParam(HTuple index, HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(809);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get one or several parameters of a metroloy model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "num_measures"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000A61 RID: 2657 RVA: 0x00041BCC File Offset: 0x0003FDCC
		public HTuple GetMetrologyObjectParam(string index, HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(809);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set fuzzy parameters or fuzzy functions for a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "fuzzy_thresh"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: 0.5</param>
		// Token: 0x06000A62 RID: 2658 RVA: 0x00041C2C File Offset: 0x0003FE2C
		public void SetMetrologyObjectFuzzyParam(HTuple index, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(810);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set fuzzy parameters or fuzzy functions for a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "fuzzy_thresh"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: 0.5</param>
		// Token: 0x06000A63 RID: 2659 RVA: 0x00041C8C File Offset: 0x0003FE8C
		public void SetMetrologyObjectFuzzyParam(string index, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(810);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters for the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "num_instances"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: 1</param>
		// Token: 0x06000A64 RID: 2660 RVA: 0x00041CE4 File Offset: 0x0003FEE4
		public void SetMetrologyObjectParam(HTuple index, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(811);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set parameters for the metrology objects of a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		/// <param name="genParamName">Names of the generic parameters. Default: "num_instances"</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: 1</param>
		// Token: 0x06000A65 RID: 2661 RVA: 0x00041D44 File Offset: 0x0003FF44
		public void SetMetrologyObjectParam(string index, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(811);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			HalconAPI.Store(proc, 2, genParamName);
			HalconAPI.Store(proc, 3, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Add a rectangle to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row (or Y) coordinate of the center of the rectangle.</param>
		/// <param name="column">Column (or X) coordinate of the center of the rectangle.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="length1">Length of the larger half edge of the rectangle.</param>
		/// <param name="length2">Length of the smaller half edge of the rectangle.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A66 RID: 2662 RVA: 0x00041D9C File Offset: 0x0003FF9C
		public int AddMetrologyObjectRectangle2Measure(HTuple row, HTuple column, HTuple phi, HTuple length1, HTuple length2, HTuple measureLength1, HTuple measureLength2, HTuple measureSigma, HTuple measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(812);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, phi);
			HalconAPI.Store(proc, 4, length1);
			HalconAPI.Store(proc, 5, length2);
			HalconAPI.Store(proc, 6, measureLength1);
			HalconAPI.Store(proc, 7, measureLength2);
			HalconAPI.Store(proc, 8, measureSigma);
			HalconAPI.Store(proc, 9, measureThreshold);
			HalconAPI.Store(proc, 10, genParamName);
			HalconAPI.Store(proc, 11, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(length1);
			HalconAPI.UnpinTuple(length2);
			HalconAPI.UnpinTuple(measureLength1);
			HalconAPI.UnpinTuple(measureLength2);
			HalconAPI.UnpinTuple(measureSigma);
			HalconAPI.UnpinTuple(measureThreshold);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a rectangle to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row (or Y) coordinate of the center of the rectangle.</param>
		/// <param name="column">Column (or X) coordinate of the center of the rectangle.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="length1">Length of the larger half edge of the rectangle.</param>
		/// <param name="length2">Length of the smaller half edge of the rectangle.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A67 RID: 2663 RVA: 0x00041E94 File Offset: 0x00040094
		public int AddMetrologyObjectRectangle2Measure(double row, double column, double phi, double length1, double length2, double measureLength1, double measureLength2, double measureSigma, double measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(812);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, length1);
			HalconAPI.StoreD(proc, 5, length2);
			HalconAPI.StoreD(proc, 6, measureLength1);
			HalconAPI.StoreD(proc, 7, measureLength2);
			HalconAPI.StoreD(proc, 8, measureSigma);
			HalconAPI.StoreD(proc, 9, measureThreshold);
			HalconAPI.Store(proc, 10, genParamName);
			HalconAPI.Store(proc, 11, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a line to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="rowBegin">Row (or Y) coordinate of the start of the line.</param>
		/// <param name="columnBegin">Column (or X) coordinate of the start of the line.</param>
		/// <param name="rowEnd">Row (or Y) coordinate of the end of the line.</param>
		/// <param name="columnEnd">Column (or X) coordinate of the end of the line.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A68 RID: 2664 RVA: 0x00041F50 File Offset: 0x00040150
		public int AddMetrologyObjectLineMeasure(HTuple rowBegin, HTuple columnBegin, HTuple rowEnd, HTuple columnEnd, HTuple measureLength1, HTuple measureLength2, HTuple measureSigma, HTuple measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(813);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, rowBegin);
			HalconAPI.Store(proc, 2, columnBegin);
			HalconAPI.Store(proc, 3, rowEnd);
			HalconAPI.Store(proc, 4, columnEnd);
			HalconAPI.Store(proc, 5, measureLength1);
			HalconAPI.Store(proc, 6, measureLength2);
			HalconAPI.Store(proc, 7, measureSigma);
			HalconAPI.Store(proc, 8, measureThreshold);
			HalconAPI.Store(proc, 9, genParamName);
			HalconAPI.Store(proc, 10, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowBegin);
			HalconAPI.UnpinTuple(columnBegin);
			HalconAPI.UnpinTuple(rowEnd);
			HalconAPI.UnpinTuple(columnEnd);
			HalconAPI.UnpinTuple(measureLength1);
			HalconAPI.UnpinTuple(measureLength2);
			HalconAPI.UnpinTuple(measureSigma);
			HalconAPI.UnpinTuple(measureThreshold);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a line to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="rowBegin">Row (or Y) coordinate of the start of the line.</param>
		/// <param name="columnBegin">Column (or X) coordinate of the start of the line.</param>
		/// <param name="rowEnd">Row (or Y) coordinate of the end of the line.</param>
		/// <param name="columnEnd">Column (or X) coordinate of the end of the line.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A69 RID: 2665 RVA: 0x00042034 File Offset: 0x00040234
		public int AddMetrologyObjectLineMeasure(double rowBegin, double columnBegin, double rowEnd, double columnEnd, double measureLength1, double measureLength2, double measureSigma, double measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(813);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowBegin);
			HalconAPI.StoreD(proc, 2, columnBegin);
			HalconAPI.StoreD(proc, 3, rowEnd);
			HalconAPI.StoreD(proc, 4, columnEnd);
			HalconAPI.StoreD(proc, 5, measureLength1);
			HalconAPI.StoreD(proc, 6, measureLength2);
			HalconAPI.StoreD(proc, 7, measureSigma);
			HalconAPI.StoreD(proc, 8, measureThreshold);
			HalconAPI.Store(proc, 9, genParamName);
			HalconAPI.Store(proc, 10, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add an ellipse or an elliptic arc to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row (or Y) coordinate of the center of the ellipse.</param>
		/// <param name="column">Column (or X) coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A6A RID: 2666 RVA: 0x000420E4 File Offset: 0x000402E4
		public int AddMetrologyObjectEllipseMeasure(HTuple row, HTuple column, HTuple phi, HTuple radius1, HTuple radius2, HTuple measureLength1, HTuple measureLength2, HTuple measureSigma, HTuple measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(814);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, phi);
			HalconAPI.Store(proc, 4, radius1);
			HalconAPI.Store(proc, 5, radius2);
			HalconAPI.Store(proc, 6, measureLength1);
			HalconAPI.Store(proc, 7, measureLength2);
			HalconAPI.Store(proc, 8, measureSigma);
			HalconAPI.Store(proc, 9, measureThreshold);
			HalconAPI.Store(proc, 10, genParamName);
			HalconAPI.Store(proc, 11, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			HalconAPI.UnpinTuple(measureLength1);
			HalconAPI.UnpinTuple(measureLength2);
			HalconAPI.UnpinTuple(measureSigma);
			HalconAPI.UnpinTuple(measureThreshold);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add an ellipse or an elliptic arc to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row (or Y) coordinate of the center of the ellipse.</param>
		/// <param name="column">Column (or X) coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A6B RID: 2667 RVA: 0x000421DC File Offset: 0x000403DC
		public int AddMetrologyObjectEllipseMeasure(double row, double column, double phi, double radius1, double radius2, double measureLength1, double measureLength2, double measureSigma, double measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(814);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, radius1);
			HalconAPI.StoreD(proc, 5, radius2);
			HalconAPI.StoreD(proc, 6, measureLength1);
			HalconAPI.StoreD(proc, 7, measureLength2);
			HalconAPI.StoreD(proc, 8, measureSigma);
			HalconAPI.StoreD(proc, 9, measureThreshold);
			HalconAPI.Store(proc, 10, genParamName);
			HalconAPI.Store(proc, 11, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a circle or a circular arc to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row coordinate (or Y) of the center of the circle or circular arc.</param>
		/// <param name="column">Column (or X) coordinate of the center of the circle or circular arc.</param>
		/// <param name="radius">Radius of the circle or circular arc.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A6C RID: 2668 RVA: 0x00042298 File Offset: 0x00040498
		public int AddMetrologyObjectCircleMeasure(HTuple row, HTuple column, HTuple radius, HTuple measureLength1, HTuple measureLength2, HTuple measureSigma, HTuple measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(815);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, radius);
			HalconAPI.Store(proc, 4, measureLength1);
			HalconAPI.Store(proc, 5, measureLength2);
			HalconAPI.Store(proc, 6, measureSigma);
			HalconAPI.Store(proc, 7, measureThreshold);
			HalconAPI.Store(proc, 8, genParamName);
			HalconAPI.Store(proc, 9, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(measureLength1);
			HalconAPI.UnpinTuple(measureLength2);
			HalconAPI.UnpinTuple(measureSigma);
			HalconAPI.UnpinTuple(measureThreshold);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Add a circle or a circular arc to a metrology model.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="row">Row coordinate (or Y) of the center of the circle or circular arc.</param>
		/// <param name="column">Column (or X) coordinate of the center of the circle or circular arc.</param>
		/// <param name="radius">Radius of the circle or circular arc.</param>
		/// <param name="measureLength1">Half length of the measure regions perpendicular to the boundary. Default: 20.0</param>
		/// <param name="measureLength2">Half length of the measure regions tangetial to the boundary. Default: 5.0</param>
		/// <param name="measureSigma">Sigma of the Gaussian function for the smoothing. Default: 1.0</param>
		/// <param name="measureThreshold">Minimum edge amplitude. Default: 30.0</param>
		/// <param name="genParamName">Names of the generic parameters. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Index of the created metrology object.</returns>
		// Token: 0x06000A6D RID: 2669 RVA: 0x0004236C File Offset: 0x0004056C
		public int AddMetrologyObjectCircleMeasure(double row, double column, double radius, double measureLength1, double measureLength2, double measureSigma, double measureThreshold, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(815);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, radius);
			HalconAPI.StoreD(proc, 4, measureLength1);
			HalconAPI.StoreD(proc, 5, measureLength2);
			HalconAPI.StoreD(proc, 6, measureSigma);
			HalconAPI.StoreD(proc, 7, measureThreshold);
			HalconAPI.Store(proc, 8, genParamName);
			HalconAPI.Store(proc, 9, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Delete a metrology model and free the allocated memory.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		// Token: 0x06000A6E RID: 2670 RVA: 0x00042414 File Offset: 0x00040614
		public void ClearMetrologyModel()
		{
			IntPtr proc = HalconAPI.PreCall(817);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete metrology objects and free the allocated memory.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A6F RID: 2671 RVA: 0x00042448 File Offset: 0x00040648
		public void ClearMetrologyObject(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(818);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete metrology objects and free the allocated memory.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="index">Index of the metrology objects. Default: "all"</param>
		// Token: 0x06000A70 RID: 2672 RVA: 0x0004248C File Offset: 0x0004068C
		public void ClearMetrologyObject(string index)
		{
			IntPtr proc = HalconAPI.PreCall(818);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, index);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the size of the image of metrology objects.
		///   Instance represents: Handle of the metrology model.
		/// </summary>
		/// <param name="width">Width of the image to be processed. Default: 640</param>
		/// <param name="height">Height of the image to be processed. Default: 480</param>
		// Token: 0x06000A71 RID: 2673 RVA: 0x000424C8 File Offset: 0x000406C8
		public void SetMetrologyModelImageSize(int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(819);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, width);
			HalconAPI.StoreI(proc, 2, height);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create the data structure that is needed to measure geometric shapes.
		///   Modified instance represents: Handle of the metrology model.
		/// </summary>
		// Token: 0x06000A72 RID: 2674 RVA: 0x0004250C File Offset: 0x0004070C
		public void CreateMetrologyModel()
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(820);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}
	}
}
